import LACparse
from ddparser import DDParser
from LAC import LAC
import json
def show_list(l):    #拼合词与其词性
    if not l:
        return
    for idx,v in enumerate(l):
        print(str(idx)+' : '+v)

#对一小句或一大句解析并返回其中可能为关系词的词
def parse_one_sentence(lac,ddp,sentence):
    seg = lac.run(sentence)
    #https://github.com/baidu/DDParser
    # print(ddp.parse_seg(seg))   #ddp解析 ，但是其解析的是句子内各词作为句子的成分的角色，例如词和词之间是并列的，但是分句之间的并列关系无法给出。
    '''
    复句类型关键触发词的词性范围
    c连词:如果,但是
    u助词:的
    d副词
    p介词
    xc其他虚词
    '''
    myrange = ['c', 'u', 'd', 'p', 'xc']

    range_result = LACparse.select_myrange(seg, myrange)
    print(sentence)
    #LACparse.show_result(range_result)
    flag_words = get_flag_words(seg,range_result)
    #print(flag_words)   #发现的特征
    type_d,flag = get_sentence_type(flag_words)
    print(type_d)
    print(flag)
    print('\n')
    sentence_d = {'text':sentence,'flag':flag,'type':type_d}

    with open('./data/output.json','a+',encoding='utf-8') as f:
        text = json.dumps(sentence_d,ensure_ascii=False)
        f.write(text)
        f.write('\n\n')

#获取关系词
def get_flag_words(seg,range_result):
    # 判断复句类型的特征的选取逻辑：
    # 1. 任意处发现某类词
    # 2. 小句开头发现某类词，标记在词后加...
    # 3. 小句结尾发现某类词，标记在词前加...
    first_word = []
    last_word = []

    for idx, v in enumerate(seg[0]):
        if idx == 0:
            first_word.append(v + '...')
            continue
        if idx == (len(seg[0])-1):
            last_word.append('...'+v)
            continue

        if v == '，':
            first_word.append(seg[0][idx + 1] + '...')
            last_word.append('...'+seg[0][idx - 1])

    words = range_result[0] + first_word + last_word
    return words

#依据关系词返回句型
def get_sentence_type(words):
    #触发词词库，构建词典是为了提高效率，对words中出现的词直接加到词典的key

    # binglie =['并','而且','则','而是','不但','且','于是...']
    # yinguo = ['既然','那么','就','如果','只要','应当']
    # zhuanzhe = ['但是','尽管','却','然而']
    # tiaojian = ['...的']
    '''扩展更多复句类型
    dijin = ['']
    chengjix = ['然后...','后...'，'后来...']
    jiashe = ['若...','如...']
    '''
    # 并列复句是指两个或两个以上的分句，分别陈述几种事物或者几种事情，或一种事情的几个方面，分句之间是平行相对的并列关系。
    binglie =['又...','同时...','且...','即...','并...','也...','并且...']
    # 因果复句直接说明因果或推论因果
    yinguo = ['因...','由于...','既然...','可见...','所以...','故...','因此...','因为...']
    # 转折复句的特点是后一分句的意思不是顺着前一分句的意思说下去，而是转到相对或相反的意思上去。
    zhuanzhe = ['但是...','但...','而...']
    # 条件复句的特点是分句之间的关系是条件和结果的关系。
    tiaojian = ['...的','如果']

    binglie_d = {'name':'并列'}   #name用于记录该字典代表的句型，字典内除name以外的其他键全为特征，例如'并','但是...'
    yinguo_d = {'name':'因果'}
    zhuanzhe_d = {'name':'转折'}
    tiaojian_d = {'name': '条件'}
    type_d = {}
    flag = []
    lists = [binglie,yinguo,zhuanzhe,tiaojian]
    dicts = [binglie_d,yinguo_d,zhuanzhe_d,tiaojian_d]

    for d in dicts:
        type_d[d['name']] = 0           #初始化标记整个句子句型的字典
    for idx,d in enumerate(dicts):
        for i in lists[idx]:
            d[i] = 0                    #将各自特征存入各自句型的字典，初始化
        for word in words:
            if word in d.keys():
                d[word] += 1            #若特征出现，则增加句子类型的计数
                flag.append(word+'/'+d['name'])
                type_d[d['name']]+=1
    return type_d,flag

if __name__ == '__main__':
    lac = LAC(mode='lac')
    ddp = DDParser()
    with open('./data/input.txt','r',encoding='utf-8') as f:
        text = f.read().replace('\n','').replace('　','')
    # l = text.split('，')     #按小句分,存在一个逻辑问题，按小句分时，实际上是遇到，和。都分。
    l = text.split('。')     #按大句分
    for i in l:
        if i == '':
            continue
        words = parse_one_sentence(lac,ddp,i)